package demo;

/**
 * Created with IntelliJ IDEA
 * Description:探讨抽象类
 * User:恋恋
 * Date:2022-09-15
 * Time:10:22
 */
abstract class Shape{
    public int a;
    protected int b;
    int c;
    private int d;
    //抽象类中能定义静态成员
    static int e;

    public Shape(int a, int b, int c, int d) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }

    private void fun0(){

    }
    public static void fun1(){

        System.out.println("抽象类中可以定义静态方法");
    }
    public final void fun2(){
        System.out.println("抽象类中可以定义final修饰方法--不能重写");
    }
    public static final void fun3(){
        System.out.println("抽象类中可以定义静态final方法--不能访问非静态成员且不能重写");
        //System.out.println(a);
    }
    //抽象方法不能有方法体（不能具体实现）
    abstract public void fun4();

//    abstract static void fun5();
//
//    abstract final void fun6();
//
//    abstract static final void fun7();
//
//    abstract private void fun8();

    //
}
//如果一个抽象类Cycle继承了一个抽象类的Shape，这个子类Cycle不要求重写父类Shape的抽象方法
//abstract class Cycle extends Shape{
//    abstract void fun9();
//
//
//}
//如果这个子类抽象类被普通类继承，就需要重写爷爷和爸爸的抽象方法
//class Triangle extends Cycle{
//    @Override
//    public void fun4() {
//
//    }
//
//    @Override
//    void fun9() {
//
//    }
//}
//如果一个普通类继承一个继承抽象类的普通类，则也不需重写爷爷的抽象方法————爷爷是抽象类，爸爸是普通类，儿子是普通类，儿子无须重写抽象方法
//class Rectangle extends Triangle{
//
//}
////一个抽象类能能继承普通类
//abstract class A extends Triangle{
//
//}
public class Test {
   public static void main(String[] args) {
      // Shape shape=new Shape();
   }
}
// abstract public void fun();